package org.example.service;

import org.example.entity.DeviceType;
import org.example.repository.DeviceTypeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Optional;

/**
 * 设备类型服务类
 */
@Service
@Transactional
public class DeviceTypeService {
    
    @Autowired
    private DeviceTypeRepository deviceTypeRepository;
    
    /**
     * 创建设备类型
     */
    public DeviceType createDeviceType(DeviceType deviceType) {
        // 检查设备类型名称是否已存在
        if (deviceTypeRepository.findByName(deviceType.getName()).isPresent()) {
            throw new RuntimeException("设备类型名称已存在");
        }
        
        return deviceTypeRepository.save(deviceType);
    }
    
    /**
     * 根据ID查找设备类型
     */
    @Transactional(readOnly = true)
    public Optional<DeviceType> findById(Long id) {
        return deviceTypeRepository.findById(id);
    }
    
    /**
     * 根据名称查找设备类型
     */
    @Transactional(readOnly = true)
    public Optional<DeviceType> findByName(String name) {
        return deviceTypeRepository.findByName(name);
    }
    
    /**
     * 获取所有设备类型
     */
    @Transactional(readOnly = true)
    public List<DeviceType> findAllDeviceTypes() {
        return deviceTypeRepository.findAll();
    }
    
    /**
     * 根据名称搜索设备类型
     */
    @Transactional(readOnly = true)
    public List<DeviceType> searchDeviceTypesByName(String name) {
        return deviceTypeRepository.findByNameContaining(name);
    }
    
    /**
     * 更新设备类型
     */
    public DeviceType updateDeviceType(DeviceType deviceType) {
        DeviceType existingDeviceType = deviceTypeRepository.findById(deviceType.getId())
                .orElseThrow(() -> new RuntimeException("设备类型不存在"));
        
        if (deviceType.getName() != null) {
            // 检查新名称是否与其他设备类型冲突
            Optional<DeviceType> conflictType = deviceTypeRepository.findByName(deviceType.getName());
            if (conflictType.isPresent() && !conflictType.get().getId().equals(deviceType.getId())) {
                throw new RuntimeException("设备类型名称已存在");
            }
            existingDeviceType.setName(deviceType.getName());
        }
        if (deviceType.getDescription() != null) {
            existingDeviceType.setDescription(deviceType.getDescription());
        }
        if (deviceType.getIcon() != null) {
            existingDeviceType.setIcon(deviceType.getIcon());
        }
        
        return deviceTypeRepository.save(existingDeviceType);
    }
    
    /**
     * 统计设备类型使用次数
     */
    @Transactional(readOnly = true)
    public long countDevicesByType(Long deviceTypeId) {
        return deviceTypeRepository.countDevicesByType(deviceTypeId);
    }
    
    /**
     * 删除设备类型
     */
    public void deleteDeviceType(Long deviceTypeId) {
        // 检查是否有设备使用该类型
        if (deviceTypeRepository.countDevicesByType(deviceTypeId) > 0) {
            throw new RuntimeException("该设备类型正在被使用，无法删除");
        }
        
        if (!deviceTypeRepository.existsById(deviceTypeId)) {
            throw new RuntimeException("设备类型不存在");
        }
        
        deviceTypeRepository.deleteById(deviceTypeId);
    }
}
